// hnum_slu_solver.h
#pragma once
#ifndef __HNUM_SLU_SOLVER_H__
#define __HNUM_SLU_SOLVER_H__

#include "hnum_slucmn.h"
#include <complex>

namespace harlinn
{
    namespace numerics
    {
        namespace SuperLU
        {

            // -----------------------------------------------------------------
            // Think of a trait as a small object whose main purpose is to carry 
            // information used by another object or algorithm to determine 
            // "policy" or "implementation details". 
            //    - Bjarne Stroustrup

            template <typename T>
            class NumericTraitsBase : public std::numeric_limits<T>
            {
            public:
                typedef T value_type;
            private:
            };

            template <typename T>
            class NumericTraits : public NumericTraitsBase<T>
            {
            public:
                typedef T value_type;
            private:
            };


            template<>
            class NumericTraits<float> : public NumericTraitsBase<float>
            {
            public:
                typedef float value_type;
            };

            template<>
            class NumericTraits<double> : public NumericTraitsBase<double>
            {
            public:
                typedef double value_type;
            };


            template<>
            class NumericTraits<complex> : public NumericTraitsBase<complex>
            {
            public:
                typedef complex value_type;
            };

            template<>
            class NumericTraits<doublecomplex> : public NumericTraitsBase<doublecomplex>
            {
            public:
                typedef doublecomplex value_type;
            };

            template<>
            class NumericTraits< std::complex<float> > : public NumericTraitsBase< std::complex<float> >
            {
            public:
                typedef std::complex<float> value_type;
            };


            template<>
            class NumericTraits< std::complex<double> > : public NumericTraitsBase< std::complex<double> >
            {
            public:
                typedef std::complex<double> value_type;
            };



            


            template <typename MatrixT_>
            class SolverTraits
            {
            public:
                typedef MatrixT_ MatrixType;
            private:

            };


            template <typename MatrixT_>
            class Solver
            {
            public:
                
            private:

            public:
                Solver()
                {}
            };
        }
    }
}



#endif //__HNUM_SLU_SOLVER_H__
